Явные вызовы деструктора

Редко возникает необходимость в явном вызове деструктора. Однако может быть полезно выполнить удаление объектов, размещенных по абсолютным адресам. Эти объекты обычно выделяются с помощью определяемого new пользователем оператора, который принимает аргумент размещения. Оператор delete не может освободить эту память, так как он не выделяется из свободного хранилища (дополнительные сведения см. в разделе "Новые и удаленные операторы"). Вызов деструктора, однако, может выполнить соответствующую очистку. Для явного вызова деструктора для объекта (s) класса String воспользуйтесь одним из следующих операторов.

  s.String::~String();    // non-virtual call
  ps->String::~String();  // non-virtual call

  s.~String();       // Virtual call
  ps->~String();     // Virtual call

Нотация для явных вызовов деструкторов, показанная в предыдущем примере, может использоваться независимо от того, определяет ли тип деструктор. Это позволяет выполнять такие явные вызовы, не зная, определен ли деструктор для типа. Явный вызов деструктора, если ни один из них не определен, не имеет никакого эффекта.

  s.String::~String();   // non-virtual call
  ps->String::~String(); // non-virtual call

  s.~String();   // Virtual call
  ps->~String(); // Virtual call

Перегрузка операторов в C++

Синтаксис перегрузки

class Integer
{
private:
    int value;
public:
    Integer(int i): value(i)
    {}
const Integer operator+(const Integer& rv) const {
      return (value + rv.value);
    }
};

Перегрузка унарных операторов

class Integer
{
private:
int value;
public:
    Integer(int i): value(i)
    {}

//унарный +
friend const Integer& operator+(const Integer& i);

//унарный -
friend const Integer operator-(const Integer& i);

//префиксный инкремент
friend const Integer& operator++(Integer& i);

//постфиксный инкремент
friend const Integer operator++(Integer& i, int);

//префиксный декремент
friend const Integer& operator--(Integer& i);

//постфиксный декремент
friend const Integer operator--(Integer& i, int);
};

//унарный плюс ничего не делает.
const Integer& operator+(const Integer& i) {
	return i.value;
}

const Integer operator-(const Integer& i) {
	return Integer(-i.value);
}

//префиксная версия возвращает значение после инкремента
const Integer& operator++(Integer& i) {
	    i.value++;
	return i;
}

//постфиксная версия возвращает значение до инкремента
const Integer operator++(Integer& i, int) {
	Integer oldValue(i.value);
	    i.value++;
	return oldValue;
}

//префиксная версия возвращает значение после декремента
const Integer& operator--(Integer& i) {
    i.value--;
    return i;
}

//постфиксная версия возвращает значение до декремента
const Integer operator--(Integer& i, int) {
Integer oldValue(i.value);
    i.value--;
    return oldValue;
}

Бинарные операторы

class Integer
{
private:
int value;
public:
    Integer(int i): value(i)
    {}
friend const Integer operator+(const Integer& left, const Integer& right);

friend Integer& operator+=(Integer& left, const Integer& right);

friend bool operator==(const Integer& left, const Integer& right);
};

const Integer operator+(const Integer& left, const Integer& right) {
	return Integer(left.value + right.value);
}

Integer& operator+=(Integer& left, const Integer& right) {
    left.value += right.value;
	return left;
}

bool operator==(const Integer& left, const Integer& right) {
	return left.value == right.value;
}

Аргументы и возвращаемые значения

• Если аргумент не изменяется оператором, в случае, например унарного плюса, его нужно передавать как ссылку на константу. Вообще, это справедливо для почти всех арифметических операторов (сложение, вычитание, умножение...)
• Тип возвращаемого значения зависит от сути оператора. Если оператор должен возвращать новое значение, то необходимо создавать новый объект (как в случае бинарного плюса). Если вы хотите запретить изменение объекта как l-value, то нужно возвращать его константным.
• Для операторов присваивания необходимо возвращать ссылку на измененный элемент. Также, если вы хотите использовать оператор присваивания в конструкциях вида (x=y).f(), где функция f() вызывается для для переменной x, после присваивания ей y, то не возвращайте ссылку на константу, возвращайте просто ссылку.
• Логические операторы должны возвращать в худшем случае int, а в лучшем bool.

Оптимизация возвращаемого значения

return Integer(left.value + right.value);

Integer temp(left.value + right.value);
	return temp;

Особые операторы

Оператор запятая

Оператор разыменования указателя

Оператор присваивания

class Integer
{
private:
    int value;
public:
    Integer(int i): value(i) {}

    Integer& operator=(const Integer& right) {
    //проверка на самоприсваивание
    if (this == &right) { return *this; }
        value = right.value;
    return *this;
    }
};

Как можно заметить, в начале функции производится проверка на самоприсваивание. Вообще, в данном случае самоприсваивание безвредно, но ситуация не всегда такая простая. Например, если объект большой, можно потратить много времени на ненужное копирование, или при работе с указателями.

Неперегружаемые операторы

• Оператор выбора члена класса ".".
• Оператор разыменования указателя на член класса ".*"
• В С++ отсутствует оператор возведения в степень (как в Fortran) "**".
• Запрещено определять свои операторы (возможны проблемы с определением приоритетов).
• Нельзя изменять приоритеты операторов

Рекомендации к форме определения операторов

+++ Пример из MSDN:

class Int
{
public:
    Int &operator++( int n );
private:
    int _i;
};
Int& Int::operator++( int n )
{   if( n != 0 )_i+=n; // Handle case where an argument is passed.
          else  _i++;  // Handle case where no argument is passed.
    return *this;
}
int main()
{ Int i;
   i.operator++( 25 ); // Increment by 25.
}

+++ операторы преобразования типов:

class A
{
    int x;

public:
    A(int _x): x(_x) {}

    operator int() const {
        return x;
    }
};

void foo() {
    A a;
    int b;
    b = a;
}